home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / PHANTCYB.ZIP / DEMO3D.PAS < prev    next >
Pascal/Delphi Source File  |  1994-08-05  |  63KB  |  1,865 lines
  1. program PHANTOM_3D_ENGINE;
  2. {+M 16384,0,32768}
  3. uses vga256,crt;
  4. const SCRWIDTH=320;
  5.       MWIDTH=128;
  6.       MCENTRE=64;
  7.       SIZE=160;           { veelvoud van 2!! }
  8.       LINES=70;           { aantal lijnen voor vloer (MAX. 70) }
  9.       KIM=29;             { hoogte tussen plafond en vloer }
  10.       XPOS=0;
  11.       DARK=1;             { donker in de verte }
  12.       DIST=3500;          { 1769 voor SIZE=320 }
  13.       HAZE=0;             { mistig in de verte }
  14.       YSHIFT=-10;         { om hem toch in het midden te krijgen }
  15.  
  16. { Bitmap 60 gaat gebruikt worden voor diverse variabelen }
  17.  
  18.       BZ=62*1024;              { BZ betekent 'Bitmap zestig' }
  19.       coltab=BZ+0;
  20.       steptab=BZ+2;
  21.       hight=BZ+4;
  22.       loop=BZ+6;
  23.       laatst=BZ+8;
  24.       vooruit=BZ+10;
  25.       terug=BZ+12;
  26.       links=BZ+14;
  27.       rechts=BZ+16;
  28.       nokke=BZ+18;
  29.       screen=BZ+20;
  30.       screen2=BZ+22;
  31.       stepsize=BZ+24;
  32.       inner=BZ+26;
  33.       htable=BZ+28;
  34.       store1=BZ+30;
  35.       store2=BZ+32;
  36.       store3=BZ+34;
  37.       stackp=BZ+36;
  38.       basep=BZ+38;
  39.       ceiling=BZ+40;
  40.       map=BZ+42;
  41.       xdelta=BZ+44;
  42.       ydelta=BZ+46;
  43.       seg1=BZ+48;
  44.       exsp=BZ+50;
  45.  
  46. { Aan het eind van de kaart worden ook nog wat variabelen bijgehouden }
  47. { De gemiddelde gestructureerde programmeur begint hier heftige braak- }
  48. { neigingen te vertonen - Sorry mensen }
  49.  
  50.       NK=32700;                { NK betekent 'na kaart' }
  51.       transp=NK+0;
  52.       xp=NK+2;
  53.       yp=NK+4;
  54.       seg3=NK+6;
  55.  
  56.  
  57. Var s1,s3,s2: word;
  58.     p1,p2,p3: pointer;
  59.     c,i,x,y,width: word;
  60.     a1,a2,a3,x1,y1: word;
  61.     sy,ss,w,bg: real;
  62.     f: file;
  63.     sn,cs: array[0..360] of real;
  64.     a: char;
  65.     b,q: byte;
  66.     s,d,x2,y2,x3,y3,r,v: integer;
  67.     cset: string;
  68.     px,py: array[0..360] of integer;
  69.     quit: boolean;
  70.     t: array[0..32] of string[33];
  71.     by: array [0..319] of longint;      {blokzak array}
  72.  
  73. procedure ScrollLava; Assembler;
  74. label regels,bytes;
  75. asm
  76.    mov ES,[s3]                { bitmap-segment }
  77.    mov DI,45*1024
  78.    mov AL,32
  79. regels:
  80.    mov CX,31
  81.    mov DL,ES:[DI]             { eerste word opslaan }
  82. bytes:
  83.    mov BL,ES:[DI+32]
  84.    mov ES:[DI],BL
  85.    add DI,32
  86.    loop bytes
  87.    mov ES:[DI],DL
  88.    sub DI,31*32-1
  89.    dec AL
  90.    jnz regels
  91. end;
  92.  
  93. procedure SetPalette;
  94. var r,g,b: array[0..31] of byte;
  95.     a,i: byte;
  96. begin
  97.    { 32 kleuren kunnen gedefinieerd worden: Alle andere worden
  98.      hieruit afgeleid (donkerder). Elk van de 32 kleuren wordt
  99.      donkerder in de diepte, in 8 stappen.                       }
  100.  
  101. {        red:     green:      blue:     description:             }
  102.  
  103.    r[ 0]:= 0; g[ 0]:= 0; b[ 0]:= 0;     { grey-scale             a }
  104.    r[ 1]:= 0; g[ 1]:= 0; b[ 1]:= 0;     { very black color       b }
  105.    r[ 2]:=63; g[ 2]:= 2; b[ 2]:= 2;     { red for squares        c }
  106.    r[ 3]:=20; g[ 3]:=50; b[ 3]:=20;     { blue-grey for doors    d }
  107.    r[ 4]:=15; g[ 4]:=40; b[ 4]:=15;     { darker blue-grey       e }
  108.    r[ 5]:=32; g[ 5]:=20; b[ 5]:= 0;     { tiles - initial        f }
  109.    r[ 6]:=30; g[ 6]:=19; b[ 6]:= 0;     { tile color 2           g }
  110.    r[ 7]:=28; g[ 7]:=18; b[ 7]:= 0;     { tile color 3           h }
  111.    r[ 8]:= 0; g[ 8]:= 0; b[ 8]:= 0;     { elevator door color 1  i }
  112.    r[ 9]:= 0; g[ 9]:= 0; b[ 9]:= 0;     { elevator door color 2  j }
  113.    r[10]:=30; g[10]:=18; b[10]:= 0;     { tile - dark version    k }
  114.    r[11]:=28; g[11]:=17; b[11]:= 0;     { dark tile color 2      l }
  115.    r[12]:=26; g[12]:=16; b[12]:= 0;     { dark tile color 3      m }
  116.    r[13]:=20; g[13]:=15; b[13]:=10;     { Brown-Yellow wall c1   n }
  117.    r[14]:=19; g[14]:=14; b[14]:= 9;     { Brown-Yellow wall c2   o }
  118.    r[15]:=18; g[15]:=13; b[15]:= 8;     { Brown-Yellow wall c3   p }
  119.    r[16]:=24; g[16]:=14; b[16]:= 0;     { Ceiling grey - color 1 q }
  120.    r[17]:=22; g[17]:=12; b[17]:= 0;     { Ceiling grey - color 2 r }
  121.    r[18]:=20; g[18]:=10; b[18]:= 0;     { Ceiling- edges         s }
  122.    r[19]:=10; g[19]:=7; b[19]:=  4;     { Wood                   t }
  123.    r[20]:= 2; g[20]:= 2; b[20]:= 2;     { Dark grey 1 (for airco)u }
  124.    r[21]:= 4; g[21]:= 4; b[21]:= 4;     { Dark grey 2            v }
  125.    r[22]:= 6; g[22]:= 6; b[22]:= 6;     { Dark grey 3            w }
  126.    r[23]:=12; g[23]:=12; b[23]:=12;     { Dark grey 4            x }
  127.    r[24]:=63; g[24]:=10; b[24]:=10;     { Vuurstroom kleur 1       }
  128.    r[25]:=55; g[25]:= 7; b[25]:= 7;     { Vuurstroom kleur 2       }
  129.    r[26]:=47; g[26]:= 4; b[26]:= 4;     { Vuurstroom kleur 3       }
  130.    r[27]:= 0; g[27]:= 0; b[27]:= 0;     {                          }
  131.    r[28]:= 0; g[28]:= 0; b[28]:= 0;     {                          }
  132.    r[29]:= 0; g[29]:= 0; b[29]:= 0;     {                          }
  133.    r[30]:= 0; g[30]:= 0; b[30]:= 0;     {                          }
  134.    r[31]:=63; g[31]:=63; b[31]:=63;     {                          }
  135.  
  136.    if (DARK=1) then for a:=0 to 7 do for i:=0 to 31 do palette(i+a*32,
  137.                                              r[i]-((r[i]*a) div 8),
  138.                                              g[i]-((g[i]*a) div 8),
  139.                                              b[i]-((b[i]*a) div 8));
  140.    if (HAZE=1) then for a:=0 to 7 do for i:=0 to 31 do palette(i+a*32,
  141.                                          r[i]+(((63-r[i])*a) div 8),
  142.                                          g[i]+(((63-g[i])*a) div 8),
  143.                                          b[i]+(((63-b[i])*a) div 8));
  144.    if (HAZE=0) and (DARK=0) then for a:=0 to 7 do for i:=0 to 31 do
  145.                                          palette(i+a*32,r[i],g[i],b[i]);
  146. end;
  147.  
  148. procedure DrawInside(xm,ym,r: integer); assembler;
  149. label q1,q2,q3,q4,picture_q1,picture_q2,drawline_q1,drawline_q2,einde
  150.       ,cx_q1,cy_q1,skipx_q1,skipx_q2,fillup
  151.       ,cx_q2,cy_q2,cy_q3,cx_q3,skipx_q3,drawline_q3,picture_q3
  152.       ,nextx,picture_q4,cy_q4,cx_q4,skipx_q4,drawline_q4
  153.       ,drawx,clear,uitgang,update,regels
  154.       ,balk_q1,balk_q2,balk_q3,balk_q4,wx_entry_q1,wx_entry_q2,wx_entry_q3
  155.       ,wx_entry_q4,wy_entry_q1,wy_entry_q2,wy_entry_q3,wy_entry_q4,skiph_q1
  156.       ,skiph_q2,skiph_q3,skiph_q4,black_q1,black_q2
  157.       ,nx_entry_q1,nx_entry_q2,nx_entry_q3,nx_entry_q4,black_q3,black_q4
  158.       ,ny_entry_q1,ny_entry_q2,ny_entry_q3,ny_entry_q4
  159.       ,special_q4,special_q1,special_q2,special_q3,scx_q1,scy_q1
  160.       ,scx_q2,scy_q2,scx_q3,scy_q3,scx_q4,scy_q4,sp_loop_q1,sp_loop_q2
  161.       ,sp_loop_q3,sp_loop_q4,sskipx_q1,sskipx_q2,sskipx_q3,sskipx_q4
  162.       ,sskipy_q1,sskipy_q2,sskipy_q3,sskipy_q4,sx_entry_q1,sx_entry_q2
  163.       ,sx_entry_q3,sx_entry_q4,sy_entry_q1,sy_entry_q2,sy_entry_q3
  164.       ,sy_entry_q4,sbalk_q1,sbalk_q2,sbalk_q3,sbalk_q4,sp_blk_q1
  165.       ,sp_blk_q2,sp_blk_q3,sp_blk_q4,no_bar_q1,no_bar_q2,no_bar_q3
  166.       ,no_bar_q4,bar_q1,bar_q2,bar_q3,bar_q4;
  167.  
  168. { This version draws a floor, a ceiling and shaded walls. }
  169. { For other features, see previous procedure.             }
  170.  
  171. asm
  172.     mov BX,[s1]
  173.     mov CX,[s3]
  174.     push DS
  175.     mov DS,CX
  176.     mov [SEG1],BX
  177.     mov DS,[SEG1]
  178.     mov [SEG3],CX
  179.     pop DS
  180.  
  181.     mov CX,[xm]
  182.     mov BX,[ym]
  183.     mov AX,[r]
  184.  
  185.     push DS
  186.     mov DS,[s1]
  187.     mov word ptr [xp],CX
  188.     mov word ptr [yp],BX
  189.     mov DS,[SEG3]
  190.     mov word ptr [basep],BP
  191.     mov word ptr [coltab],65350
  192.     mov word ptr [steptab],64600       { adres stepsize-tabel      }
  193.  
  194.     mov BX,65000
  195.     mov CX,SIZE
  196.     mov DL,200-LINES
  197. fillup:
  198.     mov DS:[BX],DL
  199.     inc BX
  200.     loop fillup
  201.     mov byte ptr [hight],2*LINES+KIM
  202.     mov BX,$A000
  203.     mov ES,BX
  204.     cmp AX,45                 { richting > 90?            }
  205.     jae q2
  206. q1:                           { rotaties van 0-89 graden  }
  207.     mov BX,AX                 { BX=rot*560                }
  208.     shl BX,9                  { BX=rot*512                }
  209.     shl AX,4                  { AX=rot*16                 }
  210.     add BX,AX                 { BX=nu rot*(512+16)        }
  211.     shl AX,1                  { AX=rot*32                 }
  212.     add BX,AX                 { BX=nu rot*(512+16+32)     }
  213.     add BX,32768              { NEG werkt niet!?          }
  214.  
  215.     mov DS,[SEG1]
  216.     mov [transp],BX           { store transtabel-pointer  }
  217.     mov DS,[SEG3]
  218.  
  219.     mov word ptr[screen],(200+YSHIFT)*320+XPOS-2+2*SIZE
  220.     mov word ptr[screen2],((198-2*LINES)-KIM+YSHIFT)*320+XPOS-2+2*SIZE
  221.  
  222.     mov word ptr [loop],LINES  { for loop=0 to 69          }
  223. picture_q1:
  224.     sub byte ptr [hight],2    { hoogteverschil scherm     }
  225.  
  226.     mov DS,[SEG1]
  227.     mov SI,[transp]           { restore transtabel-pointer}
  228.     mov AX,DS:[SI]            { start x-coord lijn        }
  229.     add AX,[xp]
  230.     mov BP,DS:[SI+2]          { start y-coord lijn        }
  231.     add BP,[yp]
  232.     mov DX,DS:[SI+4]          { xplus                     }
  233.     mov DI,DS:[SI+6]          { yplus                     }
  234.     add word ptr [transp],8
  235.     mov DS,[SEG3]
  236.  
  237.     mov [xdelta],DX           { free registers, use mem.  }
  238.     mov [ydelta],DI           { idem                      }
  239.     mov SI,AX                 { adres op map=             }
  240.     shr SI,9                  { bx shr 8+                 }
  241.     mov DI,BP                 { (cx shr 8)                }
  242.     shr DI,9
  243.     shl DI,7
  244.     add SI,DI                 { si= nu adres op map       }
  245.     mov [map],SI              { bewaar dat adres          }
  246.  
  247.     mov DS,[SEG1]
  248.     mov DI,DS:[SI+16384]
  249.     mov DS,[SEG3]
  250.  
  251.     shr DI,8
  252.     shl DI,10
  253.     mov [ceiling],DI
  254.  
  255.     mov DS,[SEG1]
  256.     mov SI,DS:[SI]            { en haal actuele veld op   }
  257.     mov DS,[SEG3]
  258.  
  259.     shr SI,8
  260.     shl AX,7                  { laagste 7 bits * 512      }
  261.     shl BP,7                  { levert start-steps op     }
  262.     xor AH,128
  263.     xor BP,32768
  264.     sub word ptr [screen],320+2*SIZE
  265.     add word ptr [screen2],320-2*SIZE
  266.     mov BX,[steptab]          { haal adres step-tabel     }
  267.     mov BX,DS:[BX]            { BX bevat nu stepsize      }
  268.     mov [stepsize],BX         { bewaar stepsize           }
  269.     add word ptr [steptab],2  { alvast voor volgende lijn }
  270.     mov BX,[coltab]           { haal adres colortabel     }
  271.     mov DX,DS:[BX]            { SP bevat colsize          }
  272.     mov [exsp],DX
  273.     add word ptr [coltab],2   { alvast voor volgende lijn }
  274.     mov word ptr [inner],SIZE { dot-counter               }
  275.     mov word ptr [htable],64999
  276.  
  277.     cmp SI,17                 { blokken 1-7               }
  278.     jb  special_q1            { speciale behandeling      }
  279.  
  280.     shl SI,10
  281.  
  282. drawline_q1:
  283.     add word ptr [screen],2
  284.     add word ptr [screen2],2
  285.     inc word ptr [htable]
  286.     mov DI,[htable]
  287.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  288.     jz  skipx_q1              { x niet meer behandelen    }
  289.     mov BX,SI                 { haal byte uit map-memory  }
  290.     mov BL,AH                 { VERY tricky piece of code }
  291.     shr BL,3
  292.     mov DI,BP
  293.     shr DI,11
  294.     shl DI,5
  295.     mov CL,DS:[DI+BX]
  296.     mov CH,CL
  297.     add CX,DX
  298.     sub DI,SI
  299.     add DI,[ceiling]
  300.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  301.     mov BH,BL
  302.     add BX,DX                 { CH en CL donkerder maken  }
  303.     mov DI,[screen2]
  304.     mov ES:[DI],BX
  305.     mov DI,[screen]
  306.     mov ES:[DI],CX
  307.     add AX,[xdelta]
  308.     jo  cx_q1
  309.     add BP,[ydelta]
  310.     jo  cy_q1
  311.     dec word ptr [inner]
  312.     jnz drawline_q1
  313.     dec word ptr [loop]       { verlaag loopcounter       }
  314.     jnz picture_q1            { volgende lijn             }
  315.     jmp einde                 { verlaat routine           }
  316. skipx_q1:
  317.     add AX,[xdelta]
  318.     jo  cx_q1
  319.     add BP,[ydelta]
  320.     jo  cy_q1
  321.     dec word ptr [inner]
  322.     jnz drawline_q1
  323.     dec word ptr [loop]       { verlaag loopcounter       }
  324.     jnz picture_q1            { volgende lijn             }
  325.     jmp einde                 { verlaat routine           }
  326. cx_q1:
  327.     inc word ptr [map]
  328.     mov SI,[map]
  329.  
  330.     mov DS,[SEG1]
  331.     mov DI,DS:[SI+16384]
  332.     mov SI,DS:[SI]
  333.     mov DS,[SEG3]
  334.  
  335.     shr SI,8
  336.     cmp SI,16
  337.     jbe sx_entry_q1
  338. wx_entry_q1:                  { dirty-jump spot           }
  339.     shr DI,8
  340.     shl DI,10
  341.     mov [ceiling],DI
  342.     shl SI,10
  343.     add BP,[ydelta]
  344.     jo  cy_q1
  345.     dec word ptr [inner]
  346.     jnz drawline_q1
  347.     dec word ptr [loop]       { verlaag loopcounter       }
  348.     jnz picture_q1            { volgende lijn             }
  349.     jmp einde                 { verlaat routine           }
  350. cy_q1:
  351.     add word ptr [map],MWIDTH
  352.     mov SI,[map]
  353.  
  354.     mov DS,[SEG1]
  355.     mov DI,DS:[SI+16384]
  356.     mov SI,DS:[SI]
  357.     mov DS,[SEG3]
  358.  
  359.     shr SI,8
  360.     cmp SI,16
  361.     jbe sy_entry_q1
  362. wy_entry_q1:                  { nasty-branch place        }
  363.     shr DI,8
  364.     shl DI,10
  365.     mov [ceiling],DI
  366.     shl SI,10
  367.     dec word ptr [inner]
  368.     jnz drawline_q1
  369.     dec word ptr [loop]       { verlaag loopcounter       }
  370.     jnz picture_q1            { volgende lijn             }
  371.     jmp einde                 { verlaat routine           }
  372.  
  373. special_q1:                   { Muren met plaatselijke    }
  374.     shl SI,10                 { balkjes (tralies ofzo)    }
  375. sp_loop_q1:
  376.     add word ptr [screen],2
  377.     add word ptr [screen2],2
  378.     inc word ptr [htable]
  379.     mov DI,[htable]
  380.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  381.     jz  sskipx_q1             { x niet meer behandelen    }
  382.     mov BX,SI                 { haal byte uit map-memory  }
  383.     mov BL,AH                 { VERY tricky piece of code }
  384.     shr BL,3
  385.     mov DI,BP
  386.     shr DI,11
  387.     shl DI,5
  388.     mov CL,DS:[DI+BX]
  389.     cmp CL,0                  { lijntje omhoog trekken    }
  390.     jz  sp_blk_q1             { speciale routine daarvoor }
  391.     mov CH,CL
  392.     add CX,DX
  393.     sub DI,SI
  394.     add DI,[ceiling]
  395.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  396.     mov BH,BL
  397.     add BX,DX                 { CH en CL donkerder maken  }
  398.     mov DI,[screen2]
  399.     mov ES:[DI],BX
  400.     mov DI,[screen]
  401.     mov ES:[DI],CX
  402.     add AX,[xdelta]
  403.     jo  scx_q1
  404.     add BP,[ydelta]
  405.     jo  scy_q1
  406.     dec word ptr [inner]
  407.     jnz sp_loop_q1
  408.     dec word ptr [loop]       { verlaag loopcounter       }
  409.     jnz picture_q1            { volgende lijn             }
  410.     jmp einde                 { verlaat routine           }
  411. sp_blk_q1:
  412.     mov DI,[htable]
  413.     mov byte ptr DS:[DI],0    { blokkeer x-coordinaat     }
  414.     mov CH,byte ptr[hight]    { Bereken hoogte muur       }
  415.     shr CX,8                  { CX is nu loop-counter     }
  416.     add CL,3                  { Iets overdrijven graag    }
  417.     mov DI,[screen]           { huidige schermadres       }
  418.     cmp CX,KIM+2*LINES+1      { maximale hoogte?          }
  419.     jz  no_bar_q1             { dan zwart tekenen         }
  420.     mov [store1],AX
  421.     mov [store2],SI
  422.     mov [store3],BP
  423.     mov BP,SI
  424.     shr BP,10
  425.     sub BP,1
  426.     mov BX,32*2048-1          { Onderaan beginnen         }
  427.     push DX
  428.     mov DX,[stepsize]         { Aantal stappen per pixel  }
  429. bar_q1:
  430.     mov SI,BX                 { bereken adres in bitmap   }
  431.     shr SI,11                 { delen door 2048           }
  432.     shl SI,5                  { *32 geeft goede adres     }
  433.     add SI,BP                 { + muurtype                }
  434.     mov AL,DS:[SI]            { haal byte op              }
  435.     mov AH,AL                 { effe 16 bits maken        }
  436.     add AX,[exsp]
  437.     mov ES:[DI],AX            { en tekenen graag          }
  438.     sub DI,320                { volgende schermregel      }
  439.     sub BX,DX                 { opschuiven in brongebied  }
  440.     loop bar_q1
  441.     pop DX
  442.     mov AX,[store1]
  443.     mov SI,[store2]
  444.     mov BP,[store3]
  445.     add AX,[xdelta]
  446.     jo  scx_q1
  447.     add BP,[ydelta]
  448.     jo  scy_q1
  449.     dec word ptr [inner]
  450.     jnz sp_loop_q1
  451.     dec word ptr [loop]       { verlaag loopcounter       }
  452.     jnz picture_q1            { volgende lijn             }
  453.     jmp einde                 { verlaat routine           }
  454. no_bar_q1:
  455.     mov word ptr ES:[DI],0
  456.     sub DI,320
  457.     loop no_bar_q1
  458.     add AX,[xdelta]
  459.     jo  scx_q1
  460.     add BP,[ydelta]
  461.     jo  scy_q1
  462.     dec word ptr [inner]
  463.     jnz sp_loop_q1
  464.     dec word ptr [loop]       { verlaag loopcounter       }
  465.     jnz picture_q1            { volgende lijn             }
  466.     jmp einde                 { verlaat routine           }
  467. sskipx_q1:
  468.     add AX,[xdelta]
  469.     jo  scx_q1
  470.     add BP,[ydelta]
  471.     jo  scy_q1
  472.     dec word ptr [inner]
  473.     jnz sp_loop_q1
  474.     dec word ptr [loop]       { verlaag loopcounter       }
  475.     jnz picture_q1            { volgende lijn             }
  476.     jmp einde                 { verlaat routine           }
  477. scx_q1:
  478.     inc word ptr [map]
  479.     mov SI,[map]
  480.  
  481.     mov DS,[SEG1]
  482.     mov DI,DS:[SI+16384]
  483.     mov SI,DS:[SI]
  484.     mov DS,[SEG3]
  485.  
  486.     shr SI,8
  487.     cmp SI,16
  488.     ja  wx_entry_q1           { gewone vloertegel         }
  489. sx_entry_q1:                  { dirty-jump spot           }
  490.     shr DI,8
  491.     shl DI,10
  492.     mov [ceiling],DI
  493.     shl SI,10
  494.     add BP,[ydelta]
  495.     jo  scy_q1
  496.     dec word ptr [inner]
  497.     jnz sp_loop_q1
  498.     dec word ptr [loop]       { verlaag loopcounter       }
  499.     jnz picture_q1            { volgende lijn             }
  500.     jmp einde                 { verlaat routine           }
  501. scy_q1:
  502.     add word ptr [map],MWIDTH
  503.     mov SI,[map]
  504.  
  505.     mov DS,[SEG1]
  506.     mov DI,DS:[SI+16384]
  507.     mov SI,DS:[SI]
  508.     mov DS,[SEG3]
  509.  
  510.     shr SI,8
  511.     cmp SI,16
  512.     ja  wx_entry_q1           { gewone vloertegels        }
  513. sy_entry_q1:                  { nasty-branch place        }
  514.     shr DI,8
  515.     shl DI,10
  516.     mov [ceiling],DI
  517.     shl SI,10
  518.     dec word ptr [inner]
  519.     jnz sp_loop_q1
  520.     dec word ptr [loop]       { verlaag loopcounter       }
  521.     jnz picture_q1            { volgende lijn             }
  522.     jmp einde                 { verlaat routine           }
  523.  
  524. q2:                           { rotaties van 0-89 graden  }
  525.     sub AX,45
  526.     cmp AX,45
  527.     jae q3
  528.     mov BX,AX                 { BX=rot*560                }
  529.     shl BX,9                  { BX=rot*512                }
  530.     shl AX,4                  { AX=rot*16                 }
  531.     add BX,AX                 { BX=nu rot*(512+16)        }
  532.     shl AX,1                  { AX=rot*32                 }
  533.     add BX,AX                 { BX=nu rot*(512+16+32)     }
  534.     add BX,32768              { NEG werkt niet!?          }
  535.  
  536.     mov DS,[SEG1]
  537.     mov [transp],BX           { store transtabel-pointer  }
  538.     mov DS,[SEG3]
  539.  
  540.     mov word ptr[screen],(200+YSHIFT)*320+XPOS-2+2*SIZE
  541.     mov word ptr[screen2],((198-2*LINES)-KIM+YSHIFT)*320+XPOS-2+2*SIZE
  542.  
  543.     mov word ptr [loop],LINES  { for loop=0 to 69          }
  544. picture_q2:
  545.     sub byte ptr [hight],2    { hoogteverschil scherm     }
  546.     mov DS,[SEG1]
  547.     mov SI,[transp]           { restore transtabel-pointer}
  548.     mov AX,[xp]
  549.     sub AX,DS:[SI+2]          { start x-coord lijn        }
  550.     mov BP,DS:[SI]            { start y-coord lijn        }
  551.     add BP,[yp]
  552.     mov DX,DS:[SI+6]          { xmin                      }
  553.     mov DI,DS:[SI+4]          { yplus                     }
  554.     add word ptr [transp],8
  555.     mov DS,[SEG3]
  556.  
  557.     mov [xdelta],DX           { free registers, use mem.  }
  558.     mov [ydelta],DI           { idem                      }
  559.     mov SI,AX                 { adres op map=             }
  560.     shr SI,9                  { bx shr 8+                 }
  561.     mov DI,BP                 { (cx shr 8)                }
  562.     shr DI,9
  563.     shl DI,7
  564.     add SI,DI                 { si= nu adres op map       }
  565.     mov [map],SI              { bewaar dat adres          }
  566.  
  567.     mov DS,[SEG1]
  568.     mov DI,DS:[SI+16384]
  569.     mov DS,[SEG3]
  570.  
  571.     shr DI,8
  572.     shl DI,10
  573.     mov [ceiling],DI
  574.  
  575.     mov DS,[SEG1]
  576.     mov SI,DS:[SI]            { en haal actuele veld op   }
  577.     mov DS,[SEG3]
  578.  
  579.     shr SI,8
  580.     shl AX,7                  { laagste 7 bits * 512      }
  581.     shl BP,7                  { levert start-steps op     }
  582.     xor AH,128
  583.     xor BP,32768
  584.     sub word ptr [screen],320+2*SIZE
  585.     add word ptr [screen2],320-2*SIZE
  586.     mov BX,[steptab]          { haal adres step-tabel     }
  587.     mov BX,DS:[BX]            { BX bevat nu stepsize      }
  588.     mov [stepsize],BX         { bewaar stepsize           }
  589.     add word ptr [steptab],2  { alvast voor volgende lijn }
  590.     mov BX,[coltab]           { haal adres colortabel     }
  591.     mov DX,DS:[BX]            { SP bevat colsize          }
  592.     mov [exsp],DX
  593.     add word ptr [coltab],2   { alvast voor volgende lijn }
  594.     mov word ptr [inner],SIZE { dot-counter               }
  595.     mov word ptr [htable],64999
  596.  
  597.     cmp SI,17                 { blokken 1-7               }
  598.     jb  special_q2            { speciale behandeling      }
  599.  
  600.     shl SI,10
  601.  
  602. drawline_q2:
  603.     add word ptr [screen],2
  604.     add word ptr [screen2],2
  605.     inc word ptr [htable]
  606.     mov DI,[htable]
  607.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  608.     jz  skipx_q2              { x niet meer behandelen    }
  609.     mov BX,SI                 { haal byte uit map-memory  }
  610.     mov BL,AH                 { VERY tricky piece of code }
  611.     shr BL,3
  612.     mov DI,BP
  613.     shr DI,11
  614.     shl DI,5
  615.     mov CL,DS:[DI+BX]
  616.     mov CH,CL
  617.     add CX,DX
  618.     sub DI,SI
  619.     add DI,[ceiling]
  620.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  621.     mov BH,BL
  622.     add BX,DX                 { CH en CL donkerder maken  }
  623.     mov DI,[screen2]
  624.     mov ES:[DI],BX
  625.     mov DI,[screen]
  626.     mov ES:[DI],CX
  627.     sub AX,[xdelta]
  628.     jo  cx_q2
  629.     add BP,[ydelta]
  630.     jo  cy_q2
  631.     dec word ptr [inner]
  632.     jnz drawline_q2
  633.     dec word ptr [loop]       { verlaag loopcounter       }
  634.     jnz picture_q2            { volgende lijn             }
  635.     jmp einde                 { verlaat routine           }
  636. skipx_q2:
  637.     sub AX,[xdelta]
  638.     jo  cx_q2
  639.     add BP,[ydelta]
  640.     jo  cy_q2
  641.     dec word ptr [inner]
  642.     jnz drawline_q2
  643.     dec word ptr [loop]       { verlaag loopcounter       }
  644.     jnz picture_q2            { volgende lijn             }
  645.     jmp einde                 { verlaat routine           }
  646. cx_q2:
  647.     dec word ptr [map]
  648.     mov SI,[map]
  649.  
  650.     mov DS,[SEG1]
  651.     mov DI,DS:[SI+16384]
  652.     mov SI,DS:[SI]
  653.     mov DS,[SEG3]
  654.  
  655.     shr SI,8
  656.     cmp SI,16
  657.     jbe sx_entry_q2
  658. wx_entry_q2:                  { dirty-jump spot           }
  659.     shr DI,8
  660.     shl DI,10
  661.     mov [ceiling],DI
  662.     shl SI,10
  663.     add BP,[ydelta]
  664.     jo  cy_q2
  665.     dec word ptr [inner]
  666.     jnz drawline_q2
  667.     dec word ptr [loop]       { verlaag loopcounter       }
  668.     jnz picture_q2            { volgende lijn             }
  669.     jmp einde                 { verlaat routine           }
  670. cy_q2:
  671.     add word ptr [map],MWIDTH
  672.     mov SI,[map]
  673.  
  674.     mov DS,[SEG1]
  675.     mov DI,DS:[SI+16384]
  676.     mov SI,DS:[SI]
  677.     mov DS,[SEG3]
  678.  
  679.     shr SI,8
  680.     cmp SI,16
  681.     jbe sy_entry_q2
  682. wy_entry_q2:                  { nasty-branch place        }
  683.     shr DI,8
  684.     shl DI,10
  685.     mov [ceiling],DI
  686.     shl SI,10
  687.     dec word ptr [inner]
  688.     jnz drawline_q2
  689.     dec word ptr [loop]       { verlaag loopcounter       }
  690.     jnz picture_q2            { volgende lijn             }
  691.     jmp einde                 { verlaat routine           }
  692.  
  693. special_q2:                   { Muren met plaatselijke    }
  694.     shl SI,10                 { balkjes (tralies ofzo)    }
  695. sp_loop_q2:
  696.     add word ptr [screen],2
  697.     add word ptr [screen2],2
  698.     inc word ptr [htable]
  699.     mov DI,[htable]
  700.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  701.     jz  sskipx_q2             { x niet meer behandelen    }
  702.     mov BX,SI                 { haal byte uit map-memory  }
  703.     mov BL,AH                 { VERY tricky piece of code }
  704.     shr BL,3
  705.     mov DI,BP
  706.     shr DI,11
  707.     shl DI,5
  708.     mov CL,DS:[DI+BX]
  709.     cmp CL,0                  { lijntje omhoog trekken    }
  710.     jz  sp_blk_q2             { speciale routine daarvoor }
  711.     mov CH,CL
  712.     add CX,DX
  713.     sub DI,SI
  714.     add DI,[ceiling]
  715.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  716.     mov BH,BL
  717.     add BX,DX                 { CH en CL donkerder maken  }
  718.     mov DI,[screen2]
  719.     mov ES:[DI],BX
  720.     mov DI,[screen]
  721.     mov ES:[DI],CX
  722.     sub AX,[xdelta]
  723.     jo  scx_q2
  724.     add BP,[ydelta]
  725.     jo  scy_q2
  726.     dec word ptr [inner]
  727.     jnz sp_loop_q2
  728.     dec word ptr [loop]       { verlaag loopcounter       }
  729.     jnz picture_q2            { volgende lijn             }
  730.     jmp einde                 { verlaat routine           }
  731. sp_blk_q2:
  732.     mov DI,[htable]
  733.     mov byte ptr DS:[DI],0    { blokkeer x-coordinaat     }
  734.     mov CH,byte ptr[hight]    { Bereken hoogte muur       }
  735.     shr CX,8                  { CX is nu loop-counter     }
  736.     add CL,3                  { Iets overdrijven graag    }
  737.     mov DI,[screen]           { huidige schermadres       }
  738.     cmp CX,KIM+2*LINES+1      { maximale hoogte?          }
  739.     jz  no_bar_q2             { dan zwart tekenen         }
  740.     mov [store1],AX
  741.     mov [store2],SI
  742.     mov [store3],BP
  743.     mov BP,SI
  744.     shr BP,10
  745.     sub BP,1
  746.     mov BX,32*2048-1          { Onderaan beginnen         }
  747.     push DX
  748.     mov DX,[stepsize]         { Aantal stappen per pixel  }
  749. bar_q2:
  750.     mov SI,BX                 { bereken adres in bitmap   }
  751.     shr SI,11                 { delen door 2048           }
  752.     shl SI,5                  { *32 geeft goede adres     }
  753.     add SI,BP                 { + muurtype                }
  754.     mov AL,DS:[SI]            { haal byte op              }
  755.     mov AH,AL                 { effe 16 bits maken        }
  756.     add AX,[exsp]
  757.     mov ES:[DI],AX            { en tekenen graag          }
  758.     sub DI,320                { volgende schermregel      }
  759.     sub BX,DX                 { opschuiven in brongebied  }
  760.     loop bar_q2
  761.     pop DX
  762.     mov AX,[store1]
  763.     mov SI,[store2]
  764.     mov BP,[store3]
  765.     sub AX,[xdelta]
  766.     jo  scx_q2
  767.     add BP,[ydelta]
  768.     jo  scy_q2
  769.     dec word ptr [inner]
  770.     jnz sp_loop_q2
  771.     dec word ptr [loop]       { verlaag loopcounter       }
  772.     jnz picture_q2            { volgende lijn             }
  773.     jmp einde                 { verlaat routine           }
  774. no_bar_q2:
  775.     mov word ptr ES:[DI],0
  776.     sub DI,320
  777.     loop no_bar_q2
  778.     sub AX,[xdelta]
  779.     jo  scx_q2
  780.     add BP,[ydelta]
  781.     jo  scy_q2
  782.     dec word ptr [inner]
  783.     jnz sp_loop_q2
  784.     dec word ptr [loop]       { verlaag loopcounter       }
  785.     jnz picture_q2            { volgende lijn             }
  786.     jmp einde                 { verlaat routine           }
  787. sskipx_q2:
  788.     sub AX,[xdelta]
  789.     jo  scx_q2
  790.     add BP,[ydelta]
  791.     jo  scy_q2
  792.     dec word ptr [inner]
  793.     jnz sp_loop_q2
  794.     dec word ptr [loop]       { verlaag loopcounter       }
  795.     jnz picture_q2            { volgende lijn             }
  796.     jmp einde                 { verlaat routine           }
  797. scx_q2:
  798.     dec word ptr [map]
  799.     mov SI,[map]
  800.  
  801.     mov DS,[SEG1]
  802.     mov DI,DS:[SI+16384]
  803.     mov SI,DS:[SI]
  804.     mov DS,[SEG3]
  805.  
  806.     shr SI,8
  807.     cmp SI,16
  808.     ja  wx_entry_q2           { gewone vloertegel         }
  809. sx_entry_q2:                  { dirty-jump spot           }
  810.     shr DI,8
  811.     shl DI,10
  812.     mov [ceiling],DI
  813.     shl SI,10
  814.     add BP,[ydelta]
  815.     jo  scy_q2
  816.     dec word ptr [inner]
  817.     jnz sp_loop_q2
  818.     dec word ptr [loop]       { verlaag loopcounter       }
  819.     jnz picture_q2            { volgende lijn             }
  820.     jmp einde                 { verlaat routine           }
  821. scy_q2:
  822.     add word ptr [map],MWIDTH
  823.     mov SI,[map]
  824.  
  825.     mov DS,[SEG1]
  826.     mov DI,DS:[SI+16384]
  827.     mov SI,DS:[SI]
  828.     mov DS,[SEG3]
  829.  
  830.     shr SI,8
  831.     cmp SI,16
  832.     ja  wx_entry_q2           { gewone vloertegels        }
  833. sy_entry_q2:                  { nasty-branch place        }
  834.     shr DI,8
  835.     shl DI,10
  836.     mov [ceiling],DI
  837.     shl SI,10
  838.     dec word ptr [inner]
  839.     jnz sp_loop_q2
  840.     dec word ptr [loop]       { verlaag loopcounter       }
  841.     jnz picture_q2            { volgende lijn             }
  842.     jmp einde                 { verlaat routine           }
  843.  
  844. q3:                           { rotaties van 0-89 graden  }
  845.     sub AX,45
  846.     cmp AX,45
  847.     jae q4
  848.     mov BX,AX                 { BX=rot*560                }
  849.     shl BX,9                  { BX=rot*512                }
  850.     shl AX,4                  { AX=rot*16                 }
  851.     add BX,AX                 { BX=nu rot*(512+16)        }
  852.     shl AX,1                  { AX=rot*32                 }
  853.     add BX,AX                 { BX=nu rot*(512+16+32)     }
  854.     add BX,32768              { NEG werkt niet!?          }
  855.  
  856.     mov DS,[SEG1]
  857.     mov [transp],BX           { store transtabel-pointer  }
  858.     mov DS,[SEG3]
  859.  
  860.     mov word ptr[screen],(200+YSHIFT)*320+XPOS-2+2*SIZE
  861.     mov word ptr[screen2],((198-2*LINES)-KIM+YSHIFT)*320+XPOS-2+2*SIZE
  862.  
  863.     mov word ptr [loop],LINES { for loop=0 to 69          }
  864. picture_q3:
  865.     sub byte ptr [hight],2    { hoogteverschil scherm     }
  866.     mov DS,[SEG1]
  867.     mov SI,[transp]           { restore transtabel-pointer}
  868.     mov AX,[xp]
  869.     sub AX,DS:[SI]            { start x-coord lijn        }
  870.     mov BP,[yp]
  871.     sub BP,DS:[SI+2]          { start y-coord lijn        }
  872.     mov DX,DS:[SI+4]          { xmin                      }
  873.     mov DI,DS:[SI+6]          { ymin                      }
  874.     add word ptr [transp],8
  875.     mov DS,[SEG3]
  876.  
  877.     mov [xdelta],DX           { free registers, use mem.  }
  878.     mov [ydelta],DI           { idem                      }
  879.     mov SI,AX                 { adres op map=             }
  880.     shr SI,9                  { bx shr 8+                 }
  881.     mov DI,BP                 { (cx shr 8)                }
  882.     shr DI,9
  883.     shl DI,7
  884.     add SI,DI                 { si= nu adres op map       }
  885.     mov [map],SI              { bewaar dat adres          }
  886.  
  887.     mov DS,[SEG1]
  888.     mov DI,DS:[SI+16384]
  889.     mov DS,[SEG3]
  890.  
  891.     shr DI,8
  892.     shl DI,10
  893.     mov [ceiling],DI
  894.  
  895.     mov DS,[SEG1]
  896.     mov SI,DS:[SI]            { en haal actuele veld op   }
  897.     mov DS,[SEG3]
  898.  
  899.     shr SI,8
  900.     shl AX,7                  { laagste 7 bits * 512      }
  901.     shl BP,7                  { levert start-steps op     }
  902.     xor AH,128
  903.     xor BP,32768
  904.     sub word ptr [screen],320+2*SIZE
  905.     add word ptr [screen2],320-2*SIZE
  906.     mov BX,[steptab]          { haal adres step-tabel     }
  907.     mov BX,DS:[BX]            { BX bevat nu stepsize      }
  908.     mov [stepsize],BX         { bewaar stepsize           }
  909.     add word ptr [steptab],2  { alvast voor volgende lijn }
  910.     mov BX,[coltab]           { haal adres colortabel     }
  911.     mov DX,DS:[BX]            { SP bevat colsize          }
  912.     mov [exsp],DX
  913.     add word ptr [coltab],2   { alvast voor volgende lijn }
  914.     mov word ptr [inner],SIZE { dot-counter               }
  915.     mov word ptr [htable],64999
  916.  
  917.     cmp SI,17                 { blokken 1-7               }
  918.     jb  special_q3            { speciale behandeling      }
  919.  
  920.     shl SI,10
  921.  
  922. drawline_q3:
  923.     add word ptr [screen],2
  924.     add word ptr [screen2],2
  925.     inc word ptr [htable]
  926.     mov DI,[htable]
  927.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  928.     jz  skipx_q3              { x niet meer behandelen    }
  929.     mov BX,SI                 { haal byte uit map-memory  }
  930.     mov BL,AH                 { VERY tricky piece of code }
  931.     shr BL,3
  932.     mov DI,BP
  933.     shr DI,11
  934.     shl DI,5
  935.     mov CL,DS:[DI+BX]
  936.     mov CH,CL
  937.     add CX,DX
  938.     sub DI,SI
  939.     add DI,[ceiling]
  940.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  941.     mov BH,BL
  942.     add BX,DX                 { CH en CL donkerder maken  }
  943.     mov DI,[screen2]
  944.     mov ES:[DI],BX
  945.     mov DI,[screen]
  946.     mov ES:[DI],CX
  947.     sub AX,[xdelta]
  948.     jo  cx_q3
  949.     sub BP,[ydelta]
  950.     jo  cy_q3
  951.     dec word ptr [inner]
  952.     jnz drawline_q3
  953.     dec word ptr [loop]       { verlaag loopcounter       }
  954.     jnz picture_q3            { volgende lijn             }
  955.     jmp einde                 { verlaat routine           }
  956. skipx_q3:
  957.     sub AX,[xdelta]
  958.     jo  cx_q3
  959.     sub BP,[ydelta]
  960.     jo  cy_q3
  961.     dec word ptr [inner]
  962.     jnz drawline_q3
  963.     dec word ptr [loop]       { verlaag loopcounter       }
  964.     jnz picture_q3            { volgende lijn             }
  965.     jmp einde                 { verlaat routine           }
  966. cx_q3:
  967.     dec word ptr [map]
  968.     mov SI,[map]
  969.  
  970.     mov DS,[SEG1]
  971.     mov DI,DS:[SI+16384]
  972.     mov SI,DS:[SI]
  973.     mov DS,[SEG3]
  974.  
  975.     shr SI,8
  976.     cmp SI,16
  977.     jbe sx_entry_q3
  978. wx_entry_q3:                  { dirty-jump spot           }
  979.     shr DI,8
  980.     shl DI,10
  981.     mov [ceiling],DI
  982.     shl SI,10
  983.     sub BP,[ydelta]
  984.     jo  cy_q3
  985.     dec word ptr [inner]
  986.     jnz drawline_q3
  987.     dec word ptr [loop]       { verlaag loopcounter       }
  988.     jnz picture_q3            { volgende lijn             }
  989.     jmp einde                 { verlaat routine           }
  990. cy_q3:
  991.     sub word ptr [map],MWIDTH
  992.     mov SI,[map]
  993.  
  994.     mov DS,[SEG1]
  995.     mov DI,DS:[SI+16384]
  996.     mov SI,DS:[SI]
  997.     mov DS,[SEG3]
  998.  
  999.     shr SI,8
  1000.     cmp SI,16
  1001.     jbe sy_entry_q3
  1002. wy_entry_q3:                  { nasty-branch place        }
  1003.     shr DI,8
  1004.     shl DI,10
  1005.     mov [ceiling],DI
  1006.     shl SI,10
  1007.     dec word ptr [inner]
  1008.     jnz drawline_q3
  1009.     dec word ptr [loop]       { verlaag loopcounter       }
  1010.     jnz picture_q3            { volgende lijn             }
  1011.     jmp einde                 { verlaat routine           }
  1012.  
  1013. special_q3:                   { Muren met plaatselijke    }
  1014.     shl SI,10                 { balkjes (tralies ofzo)    }
  1015. sp_loop_q3:
  1016.     add word ptr [screen],2
  1017.     add word ptr [screen2],2
  1018.     inc word ptr [htable]
  1019.     mov DI,[htable]
  1020.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  1021.     jz  sskipx_q3             { x niet meer behandelen    }
  1022.     mov BX,SI                 { haal byte uit map-memory  }
  1023.     mov BL,AH                 { VERY tricky piece of code }
  1024.     shr BL,3
  1025.     mov DI,BP
  1026.     shr DI,11
  1027.     shl DI,5
  1028.     mov CL,DS:[DI+BX]
  1029.     cmp CL,0                  { lijntje omhoog trekken    }
  1030.     jz  sp_blk_q3             { speciale routine daarvoor }
  1031.     mov CH,CL
  1032.     add CX,DX
  1033.     sub DI,SI
  1034.     add DI,[ceiling]
  1035.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  1036.     mov BH,BL
  1037.     add BX,DX                 { CH en CL donkerder maken  }
  1038.     mov DI,[screen2]
  1039.     mov ES:[DI],BX
  1040.     mov DI,[screen]
  1041.     mov ES:[DI],CX
  1042.     sub AX,[xdelta]
  1043.     jo  scx_q3
  1044.     sub BP,[ydelta]
  1045.     jo  scy_q3
  1046.     dec word ptr [inner]
  1047.     jnz sp_loop_q3
  1048.     dec word ptr [loop]       { verlaag loopcounter       }
  1049.     jnz picture_q3            { volgende lijn             }
  1050.     jmp einde                 { verlaat routine           }
  1051. sp_blk_q3:
  1052.     mov DI,[htable]
  1053.     mov byte ptr DS:[DI],0    { blokkeer x-coordinaat     }
  1054.     mov CH,byte ptr[hight]    { Bereken hoogte muur       }
  1055.     shr CX,8                  { CX is nu loop-counter     }
  1056.     add CL,3                  { Iets overdrijven graag    }
  1057.     mov DI,[screen]           { huidige schermadres       }
  1058.     cmp CX,KIM+2*LINES+1      { maximale hoogte?          }
  1059.     jz  no_bar_q3             { dan zwart tekenen         }
  1060.     mov [store1],AX
  1061.     mov [store2],SI
  1062.     mov [store3],BP
  1063.     mov BP,SI
  1064.     shr BP,10
  1065.     sub BP,1
  1066.     mov BX,32*2048-1          { Onderaan beginnen         }
  1067.     push DX
  1068.     mov DX,[stepsize]         { Aantal stappen per pixel  }
  1069. bar_q3:
  1070.     mov SI,BX                 { bereken adres in bitmap   }
  1071.     shr SI,11                 { delen door 2048           }
  1072.     shl SI,5                  { *32 geeft goede adres     }
  1073.     add SI,BP                 { + muurtype                }
  1074.     mov AL,DS:[SI]            { haal byte op              }
  1075.     mov AH,AL                 { effe 16 bits maken        }
  1076.     add AX,[exsp]
  1077.     mov ES:[DI],AX            { en tekenen graag          }
  1078.     sub DI,320                { volgende schermregel      }
  1079.     sub BX,DX                 { opschuiven in brongebied  }
  1080.     loop bar_q3
  1081.     pop DX
  1082.     mov AX,[store1]
  1083.     mov SI,[store2]
  1084.     mov BP,[store3]
  1085.     sub AX,[xdelta]
  1086.     jo  scx_q3
  1087.     sub BP,[ydelta]
  1088.     jo  scy_q3
  1089.     dec word ptr [inner]
  1090.     jnz sp_loop_q3
  1091.     dec word ptr [loop]       { verlaag loopcounter       }
  1092.     jnz picture_q3            { volgende lijn             }
  1093.     jmp einde                 { verlaat routine           }
  1094. no_bar_q3:
  1095.     mov word ptr ES:[DI],0
  1096.     sub DI,320
  1097.     loop no_bar_q3
  1098.     sub AX,[xdelta]
  1099.     jo  scx_q3
  1100.     sub BP,[ydelta]
  1101.     jo  scy_q3
  1102.     dec word ptr [inner]
  1103.     jnz sp_loop_q3
  1104.     dec word ptr [loop]       { verlaag loopcounter       }
  1105.     jnz picture_q3            { volgende lijn             }
  1106.     jmp einde                 { verlaat routine           }
  1107. sskipx_q3:
  1108.     sub AX,[xdelta]
  1109.     jo  scx_q3
  1110.     sub BP,[ydelta]
  1111.     jo  scy_q3
  1112.     dec word ptr [inner]
  1113.     jnz sp_loop_q3
  1114.     dec word ptr [loop]       { verlaag loopcounter       }
  1115.     jnz picture_q3            { volgende lijn             }
  1116.     jmp einde                 { verlaat routine           }
  1117. scx_q3:
  1118.     dec word ptr [map]
  1119.     mov SI,[map]
  1120.  
  1121.     mov DS,[SEG1]
  1122.     mov DI,DS:[SI+16384]
  1123.     mov SI,DS:[SI]
  1124.     mov DS,[SEG3]
  1125.  
  1126.     shr SI,8
  1127.     cmp SI,16
  1128.     ja  wx_entry_q3           { gewone vloertegel         }
  1129. sx_entry_q3:                  { dirty-jump spot           }
  1130.     shr DI,8
  1131.     shl DI,10
  1132.     mov [ceiling],DI
  1133.     shl SI,10
  1134.     sub BP,[ydelta]
  1135.     jo  scy_q3
  1136.     dec word ptr [inner]
  1137.     jnz sp_loop_q3
  1138.     dec word ptr [loop]       { verlaag loopcounter       }
  1139.     jnz picture_q3            { volgende lijn             }
  1140.     jmp einde                 { verlaat routine           }
  1141. scy_q3:
  1142.     sub word ptr [map],MWIDTH
  1143.     mov SI,[map]
  1144.  
  1145.     mov DS,[SEG1]
  1146.     mov DI,DS:[SI+16384]
  1147.     mov SI,DS:[SI]
  1148.     mov DS,[SEG3]
  1149.  
  1150.     shr SI,8
  1151.     cmp SI,16
  1152.     ja  wx_entry_q3           { gewone vloertegels        }
  1153. sy_entry_q3:                  { nasty-branch place        }
  1154.     shr DI,8
  1155.     shl DI,10
  1156.     mov [ceiling],DI
  1157.     shl SI,10
  1158.     dec word ptr [inner]
  1159.     jnz sp_loop_q3
  1160.     dec word ptr [loop]       { verlaag loopcounter       }
  1161.     jnz picture_q3            { volgende lijn             }
  1162.     jmp einde                 { verlaat routine           }
  1163.  
  1164. q4:                           { rotaties van 0-89 graden  }
  1165.     sub AX,45
  1166.     mov BX,AX                 { BX=rot*560                }
  1167.     shl BX,9                  { BX=rot*512                }
  1168.     shl AX,4                  { AX=rot*16                 }
  1169.     add BX,AX                 { BX=nu rot*(512+16)        }
  1170.     shl AX,1                  { AX=rot*32                 }
  1171.     add BX,AX                 { BX=nu rot*(512+16+32)     }
  1172.     add BX,32768              { NEG werkt niet!?          }
  1173.  
  1174.     mov DS,[SEG1]
  1175.     mov [transp],BX           { store transtabel-pointer  }
  1176.     mov DS,[SEG3]
  1177.  
  1178.     mov word ptr[screen],(200+YSHIFT)*320+XPOS-2+2*SIZE
  1179.     mov word ptr[screen2],((198-2*LINES)-KIM+YSHIFT)*320+XPOS-2+2*SIZE
  1180.  
  1181.     mov word ptr [loop],LINES { for loop=0 to 69          }
  1182.  
  1183. picture_q4:
  1184.     sub byte ptr [hight],2    { hoogteverschil scherm     }
  1185.     mov DS,[SEG1]
  1186.     mov SI,[transp]           { restore transtabel-pointer}
  1187.     mov AX,DS:[SI+2]          { start x-coord lijn        }
  1188.     add AX,[xp]
  1189.     mov BP,[yp]
  1190.     sub BP,DS:[SI]            { start y-coord lijn        }
  1191.     mov DX,DS:[SI+6]          { xplus                     }
  1192.     mov DI,DS:[SI+4]          { ymin                      }
  1193.     add word ptr [transp],8
  1194.     mov DS,[SEG3]
  1195.  
  1196.     mov [xdelta],DX           { free registers, use mem.  }
  1197.     mov [ydelta],DI           { idem                      }
  1198.     mov SI,AX                 { adres op map=             }
  1199.     shr SI,9                  { bx shr 8+                 }
  1200.     mov DI,BP                 { (cx shr 8)                }
  1201.     shr DI,9
  1202.     shl DI,7
  1203.     add SI,DI                 { si= nu adres op map       }
  1204.     mov [map],SI              { bewaar dat adres          }
  1205.  
  1206.     mov DS,[SEG1]
  1207.     mov DI,DS:[SI+16384]
  1208.     mov DS,[SEG3]
  1209.  
  1210.     shr DI,8
  1211.     shl DI,10
  1212.     mov [ceiling],DI
  1213.  
  1214.     mov DS,[SEG1]
  1215.     mov SI,DS:[SI]            { en haal actuele veld op   }
  1216.     mov DS,[SEG3]
  1217.  
  1218.     shr SI,8
  1219.     shl AX,7                  { laagste 7 bits * 512      }
  1220.     shl BP,7                  { levert start-steps op     }
  1221.     xor AH,128
  1222.     xor BP,32768
  1223.     sub word ptr [screen],320+2*SIZE
  1224.     add word ptr [screen2],320-2*SIZE
  1225.     mov BX,[steptab]          { haal adres step-tabel     }
  1226.     mov BX,DS:[BX]            { BX bevat nu stepsize      }
  1227.     mov [stepsize],BX         { bewaar stepsize           }
  1228.     add word ptr [steptab],2  { alvast voor volgende lijn }
  1229.     mov BX,[coltab]           { haal adres colortabel     }
  1230.     mov DX,DS:[BX]            { SP bevat colsize          }
  1231.     mov [exsp],DX
  1232.     add word ptr [coltab],2   { alvast voor volgende lijn }
  1233.     mov word ptr [inner],SIZE { dot-counter               }
  1234.     mov word ptr [htable],64999
  1235.  
  1236.     cmp SI,17                 { blokken 1-7               }
  1237.     jb  special_q4            { speciale behandeling      }
  1238.  
  1239.     shl SI,10
  1240.  
  1241. drawline_q4:
  1242.     add word ptr [screen],2
  1243.     add word ptr [screen2],2
  1244.     inc word ptr [htable]
  1245.     mov DI,[htable]
  1246.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  1247.     jz  skipx_q4              { x niet meer behandelen    }
  1248.     mov BX,SI                 { haal byte uit map-memory  }
  1249.     mov BL,AH                 { VERY tricky piece of code }
  1250.     shr BL,3
  1251.     mov DI,BP
  1252.     shr DI,11
  1253.     shl DI,5
  1254.     mov CL,DS:[DI+BX]
  1255.     mov CH,CL
  1256.     add CX,DX
  1257.     sub DI,SI
  1258.     add DI,[ceiling]
  1259.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  1260.     mov BH,BL
  1261.     add BX,DX                 { CH en CL donkerder maken  }
  1262.     mov DI,[screen2]
  1263.     mov ES:[DI],BX
  1264.     mov DI,[screen]
  1265.     mov ES:[DI],CX
  1266.     add AX,[xdelta]
  1267.     jo  cx_q4
  1268.     sub BP,[ydelta]
  1269.     jo  cy_q4
  1270.     dec word ptr [inner]
  1271.     jnz drawline_q4
  1272.     dec word ptr [loop]       { verlaag loopcounter       }
  1273.     jnz picture_q4            { volgende lijn             }
  1274.     jmp einde                 { verlaat routine           }
  1275. skipx_q4:
  1276.     add AX,[xdelta]
  1277.     jo  cx_q4
  1278.     sub BP,[ydelta]
  1279.     jo  cy_q4
  1280.     dec word ptr [inner]
  1281.     jnz drawline_q4
  1282.     dec word ptr [loop]       { verlaag loopcounter       }
  1283.     jnz picture_q4            { volgende lijn             }
  1284.     jmp einde                 { verlaat routine           }
  1285. cx_q4:
  1286.     inc word ptr [map]
  1287.     mov SI,[map]
  1288.  
  1289.     mov DS,[SEG1]
  1290.     mov DI,DS:[SI+16384]
  1291.     mov SI,DS:[SI]
  1292.     mov DS,[SEG3]
  1293.  
  1294.     shr SI,8
  1295.     cmp SI,16
  1296.     jbe sx_entry_q4
  1297. wx_entry_q4:                  { dirty-jump spot           }
  1298.     shr DI,8
  1299.     shl DI,10
  1300.     mov [ceiling],DI
  1301.     shl SI,10
  1302.     sub BP,[ydelta]
  1303.     jo  cy_q4
  1304.     dec word ptr [inner]
  1305.     jnz drawline_q4
  1306.     dec word ptr [loop]       { verlaag loopcounter       }
  1307.     jnz picture_q4            { volgende lijn             }
  1308.     jmp einde                 { verlaat routine           }
  1309. cy_q4:
  1310.     sub word ptr [map],MWIDTH
  1311.     mov SI,[map]
  1312.  
  1313.     mov DS,[SEG1]
  1314.     mov DI,DS:[SI+16384]
  1315.     mov SI,DS:[SI]
  1316.     mov DS,[SEG3]
  1317.  
  1318.     shr SI,8
  1319.     cmp SI,16
  1320.     jbe sy_entry_q4
  1321. wy_entry_q4:                  { nasty-branch place        }
  1322.     shr DI,8
  1323.     shl DI,10
  1324.     mov [ceiling],DI
  1325.     shl SI,10
  1326.     dec word ptr [inner]
  1327.     jnz drawline_q4
  1328.     dec word ptr [loop]       { verlaag loopcounter       }
  1329.     jnz picture_q4            { volgende lijn             }
  1330.     jmp einde                 { verlaat routine           }
  1331.  
  1332. special_q4:                   { Muren met plaatselijke    }
  1333.     shl SI,10                 { balkjes (tralies ofzo)    }
  1334. sp_loop_q4:
  1335.     add word ptr [screen],2
  1336.     add word ptr [screen2],2
  1337.     inc word ptr [htable]
  1338.     mov DI,[htable]
  1339.     cmp byte ptr DS:[DI],0    { cmp SS:[htable] gaat fout }
  1340.     jz  sskipx_q4             { x niet meer behandelen    }
  1341.     mov BX,SI                 { haal byte uit map-memory  }
  1342.     mov BL,AH                 { VERY tricky piece of code }
  1343.     shr BL,3
  1344.     mov DI,BP
  1345.     shr DI,11
  1346.     shl DI,5
  1347.     mov CL,DS:[DI+BX]
  1348.     cmp CL,0                  { lijntje omhoog trekken    }
  1349.     jz  sp_blk_q4             { speciale routine daarvoor }
  1350.     mov CH,CL
  1351.     add CX,DX
  1352.     sub DI,SI
  1353.     add DI,[ceiling]
  1354.     mov BL,DS:[DI+BX]         { BL bevat plafond-pixel    }
  1355.     mov BH,BL
  1356.     add BX,DX                 { CH en CL donkerder maken  }
  1357.     mov DI,[screen2]
  1358.     mov ES:[DI],BX
  1359.     mov DI,[screen]
  1360.     mov ES:[DI],CX
  1361.     add AX,[xdelta]
  1362.     jo  scx_q4
  1363.     sub BP,[ydelta]
  1364.     jo  scy_q4
  1365.     dec word ptr [inner]
  1366.     jnz sp_loop_q4
  1367.     dec word ptr [loop]       { verlaag loopcounter       }
  1368.     jnz picture_q4            { volgende lijn             }
  1369.     jmp einde                 { verlaat routine           }
  1370. sp_blk_q4:
  1371.     mov DI,[htable]
  1372.     mov byte ptr DS:[DI],0    { blokkeer x-coordinaat     }
  1373.     mov CH,byte ptr[hight]    { Bereken hoogte muur       }
  1374.     shr CX,8                  { CX is nu loop-counter     }
  1375.     add CL,3                  { Iets overdrijven graag    }
  1376.     mov DI,[screen]           { huidige schermadres       }
  1377.     cmp CX,KIM+2*LINES+1      { maximale hoogte?          }
  1378.     jz  no_bar_q4             { dan zwart tekenen         }
  1379.     mov [store1],AX
  1380.     mov [store2],SI
  1381.     mov [store3],BP
  1382.     mov BP,SI
  1383.     shr BP,10
  1384.     sub BP,1
  1385.     mov BX,32*2048-1          { Onderaan beginnen         }
  1386.     push DX
  1387.     mov DX,[stepsize]         { Aantal stappen per pixel  }
  1388. bar_q4:
  1389.     mov SI,BX                 { bereken adres in bitmap   }
  1390.     shr SI,11                 { delen door 2048           }
  1391.     shl SI,5                  { *32 geeft goede adres     }
  1392.     add SI,BP                 { + muurtype                }
  1393.     mov AL,DS:[SI]            { haal byte op              }
  1394.     mov AH,AL                 { effe 16 bits maken        }
  1395.     add AX,[exsp]
  1396.     mov ES:[DI],AX            { en tekenen graag          }
  1397.     sub DI,320                { volgende schermregel      }
  1398.     sub BX,DX                 { opschuiven in brongebied  }
  1399.     loop bar_q4
  1400.     pop DX
  1401.     mov AX,[store1]
  1402.     mov SI,[store2]
  1403.     mov BP,[store3]
  1404.     add AX,[xdelta]
  1405.     jo  scx_q4
  1406.     sub BP,[ydelta]
  1407.     jo  scy_q4
  1408.     dec word ptr [inner]
  1409.     jnz sp_loop_q4
  1410.     dec word ptr [loop]       { verlaag loopcounter       }
  1411.     jnz picture_q4            { volgende lijn             }
  1412.     jmp einde                 { verlaat routine           }
  1413. no_bar_q4:
  1414.     mov word ptr ES:[DI],0
  1415.     sub DI,320
  1416.     loop no_bar_q4
  1417.     sub AX,[xdelta]
  1418.     jo  scx_q4
  1419.     sub BP,[ydelta]
  1420.     jo  scy_q4
  1421.     dec word ptr [inner]
  1422.     jnz sp_loop_q4
  1423.     dec word ptr [loop]       { verlaag loopcounter       }
  1424.     jnz picture_q4            { volgende lijn             }
  1425.     jmp einde                 { verlaat routine           }
  1426. sskipx_q4:
  1427.     add AX,[xdelta]
  1428.     jo  scx_q4
  1429.     sub BP,[ydelta]
  1430.     jo  scy_q4
  1431.     dec word ptr [inner]
  1432.     jnz sp_loop_q4
  1433.     dec word ptr [loop]       { verlaag loopcounter       }
  1434.     jnz picture_q4            { volgende lijn             }
  1435.     jmp einde                 { verlaat routine           }
  1436. scx_q4:
  1437.     inc word ptr [map]
  1438.     mov SI,[map]
  1439.  
  1440.     mov DS,[SEG1]
  1441.     mov DI,DS:[SI+16384]
  1442.     mov SI,DS:[SI]
  1443.     mov DS,[SEG3]
  1444.  
  1445.     shr SI,8
  1446.     cmp SI,16
  1447.     ja  wx_entry_q4           { gewone vloertegel         }
  1448. sx_entry_q4:                  { dirty-jump spot           }
  1449.     shr DI,8
  1450.     shl DI,10
  1451.     mov [ceiling],DI
  1452.     shl SI,10
  1453.     sub BP,[ydelta]
  1454.     jo  scy_q4
  1455.     dec word ptr [inner]
  1456.     jnz sp_loop_q4
  1457.     dec word ptr [loop]       { verlaag loopcounter       }
  1458.     jnz picture_q4            { volgende lijn             }
  1459.     jmp einde                 { verlaat routine           }
  1460. scy_q4:
  1461.     sub word ptr [map],MWIDTH
  1462.     mov SI,[map]
  1463.  
  1464.     mov DS,[SEG1]
  1465.     mov DI,DS:[SI+16384]
  1466.     mov SI,DS:[SI]
  1467.     mov DS,[SEG3]
  1468.  
  1469.     shr SI,8
  1470.     cmp SI,16
  1471.     ja  wx_entry_q4           { gewone vloertegels        }
  1472. sy_entry_q4:                  { nasty-branch place        }
  1473.     shr DI,8
  1474.     shl DI,10
  1475.     mov [ceiling],DI
  1476.     shl SI,10
  1477.     dec word ptr [inner]
  1478.     jnz sp_loop_q4
  1479.     dec word ptr [loop]       { verlaag loopcounter       }
  1480.     jnz picture_q4            { volgende lijn             }
  1481.     jmp einde                 { verlaat routine           }
  1482.  
  1483.  
  1484. einde:
  1485.     mov DI,XPOS+((199-(LINES-YSHIFT))-KIM)*320
  1486.                               { beginadres huidige x      }
  1487.     mov BP,SIZE               { loopcounter (horizontaal  }
  1488.     mov SI,65000              { adres htable              }
  1489.     mov AL,0
  1490.     mov DL,255*HAZE
  1491.     mov DH,DL
  1492. clear:
  1493.     cmp DS:[SI],AL            { staat daar een muur?      }
  1494.     jz nextx                  { ja: volgende x positie    }
  1495.     mov CX,KIM+1              { anders lijntje trekken    }
  1496.     mov BX,DI                 { haal beginadres op        }
  1497. drawx:
  1498.     mov ES:[BX],DX            { zet een byte neer         }
  1499.     add BX,320                { volgende regel            }
  1500.     loop drawx
  1501. nextx:
  1502.     add DI,2
  1503.     inc SI
  1504.     dec BP                    { volgende kolom graag      }
  1505.     jnz clear
  1506.     mov BP,word ptr [basep]
  1507.     pop DS
  1508.  
  1509. end;
  1510.  
  1511. procedure Move(d: string; r1,r2,dr,t1,t2,ds,vr1,vr2,vrs: integer);
  1512. { Demo-sequence command parser }
  1513. var rr,sr: integer;     {richting en snelheid van veranderingen}
  1514.     nokke: boolean;
  1515.     i: word;
  1516. begin
  1517.     if (r1<>0) or (t1<>0) or (vrs<>0) then begin
  1518.        if (r1=0) and (r2=0) then begin
  1519.           r1:=r;
  1520.           r2:=r;
  1521.           dr:=0;
  1522.        end;
  1523.        if (t1=0) and (t2=0) then begin
  1524.           t1:=v;
  1525.           t2:=v;
  1526.           ds:=0;
  1527.        end;
  1528.        if (vr1=0) and (vr2=0) then begin   {follow direction}
  1529.           vr1:=r1;
  1530.           vr2:=r2;
  1531.           vrs:=dr;
  1532.        end;
  1533.        r:=r1;
  1534.        v:=t1;
  1535.        repeat
  1536.           r:=r+dr;
  1537.           if (r>179) then r:=r-180;
  1538.           if (r<0) then r:=r+180;
  1539.           if (r=r2) then dr:=0;
  1540.           v:=v+ds;
  1541.           if (v=t2) then ds:=0;
  1542.           vr1:=vr1+vrs;
  1543.           if (vr1>179) then vr1:=vr1-180;
  1544.           if (vr1<0) then vr1:=vr1+180;
  1545.           if (vr1=vr2) then vrs:=0;
  1546.           x2:=x2+((px[r]*v) div 100);
  1547.           y2:=y2+((py[r]*v) div 100);
  1548.           ScrollLava;
  1549.           DrawInside(x2,y2,vr1);
  1550.           WaitVbl;
  1551.        until ((ds=0) and (dr=0) and (vrs=0)) or keypressed;
  1552.     end else if (dr>0) then begin
  1553.        repeat
  1554.           x2:=x2+((px[r]*v) div 100);
  1555.           y2:=y2+((py[r]*v) div 100);
  1556.           dr:=dr-1;
  1557.           ScrollLava;
  1558.           DrawInside(x2,y2,r);
  1559.           WaitVbl;
  1560.        until (dr=0) or keypressed;
  1561.     end;
  1562.     if keypressed then quit:=True;
  1563. end;
  1564.  
  1565. procedure Initialize;
  1566. begin
  1567.     for i:=0 to 360 do begin
  1568.        sn[i]:=sin((i*3.14159)/180);
  1569.        cs[i]:=cos((i*3.14159)/180);
  1570.     end;
  1571.  
  1572.     GetMem(p1,65535);
  1573.     GetMem(p3,65535);
  1574.     assign (f,'3dspace.wad');
  1575.     reset(f,1);
  1576.     BlockRead(f,p1^,65535);
  1577.     BlockRead(f,p3^,65535);
  1578.     close(f);
  1579.  
  1580.     s3:=Seg(p3^);
  1581.     s1:=Seg(p1^);
  1582.  
  1583.     InitScreen;
  1584.     NCls(0);
  1585.     for i:=0 to 255 do palette(i,0,0,0);
  1586.  
  1587.     {Achtergrond voor scroller opslaan}
  1588.     x2:=-1551;
  1589.     y2:=-9232;
  1590.     r:=90;
  1591.     v:=0;
  1592.     DrawInside(x2-21*512,y2,r);
  1593.     GetMem(p2,64000);
  1594.     s2:=Seg(p2^);
  1595.     for a1:=0 to 15999 do meml[s2:a1 shl 2]:=meml[$a000:a1 shl 2];
  1596.     NCls(0);
  1597.     SetPalette;
  1598.  
  1599.     for i:=0 to 179 do begin
  1600.        px[i]:=round(sin(i*3.14159/90)*100);
  1601.        py[i]:=round(-cos(i*3.14159/90)*100);
  1602.     end;
  1603.  
  1604. end;
  1605.  
  1606. procedure SetColor(n,x,y,z: byte);
  1607. var i: byte;
  1608. begin
  1609.    for i:=0 to 7 do palette(n+i*32,x-(x*i) div 8,y-(y*i) div 8,z-(z*i) div 8);
  1610. end;
  1611.  
  1612. procedure EndOfDemo;
  1613. begin
  1614.     TextMode(LastMode);
  1615.     ClrScr;
  1616. end;
  1617.  
  1618. procedure FloorPixel(n,x,y: byte);
  1619. var a: word;
  1620. begin
  1621.    a:=((x+16) mod 32)+32*((y+16) mod 32);
  1622.    mem[s3:a+n*1024]:=mem[s3:a+57*1024];
  1623. end;
  1624.  
  1625. procedure DarkPixel(n,x,y,c: byte);
  1626. var a: word;
  1627. begin
  1628.    a:=((x+16) mod 32)+32*((y+16) mod 32);
  1629.    mem[s3:a+n*1024]:=c;
  1630. end;
  1631.  
  1632.  
  1633. {/////////////////////////////////////////////////////////////////////}
  1634. {///                                                               ///}
  1635. {///          THE   ANIMATION !!                                   ///}
  1636. {///                                                               ///}
  1637. {/////////////////////////////////////////////////////////////////////}
  1638.  
  1639.  
  1640. begin
  1641.   Initialize;
  1642.  
  1643.   v:=0;
  1644.   Quit:=False;
  1645.                        {'description', r1, r2,dr,  s1,  s2,ds,vr1,vr2,vrs}
  1646.                        {'-----------  --- --- -- ---- ---- --}
  1647.   { Make elevator door visible }
  1648.   for i:=0 to 7 do begin
  1649.      SetColor(8,50,50,55);
  1650.      SetColor(9,45,45,50);
  1651.   end;
  1652.  
  1653.   x2:=-6953;
  1654.   y2:=13417;
  1655.   r:=143;
  1656.  
  1657.   { Open the elevator door }
  1658.   if not quit then begin
  1659.      for i:=0 to 59 do begin
  1660.         for b:=10 to 19 do begin
  1661.            DarkPixel(14,b,i div 2,12);
  1662.            DarkPixel(15,b,31-i div 2,12);
  1663.         end;
  1664.         DarkPixel(14,20,i div 2,1);
  1665.         DarkPixel(14,21,i div 2,1);
  1666.         DarkPixel(15,20,31-i div 2,1);
  1667.         DarkPixel(15,21,31-i div 2,1);
  1668.         if i<31 then begin
  1669.            for b:=0 to 9 do begin
  1670.               FloorPixel(14,b,i);
  1671.               FloorPixel(14,b,i+1);
  1672.               FloorPixel(15,b,31-i);
  1673.               FloorPixel(15,b,30-i);
  1674.            end;
  1675.            for b:=22 to 31 do begin
  1676.               FloorPixel(14,b,i);
  1677.               FloorPixel(14,b,i+1);
  1678.               FloorPixel(15,b,31-i);
  1679.               FloorPixel(15,b,30-i);
  1680.            end;
  1681.         end;
  1682.         DrawInside(x2,y2,r);
  1683.      end;
  1684.   end;
  1685.  
  1686.   { Start of part two: Cam. is now right in front of elevator }
  1687.   if not quit then Move('Go in room ',143,138,-1,   1,  71, 2,  0,  0, 0);
  1688.   if not quit then Move('Stop       ',  0,  0, 2,  70,   0,-2,  0,  0, 0);
  1689.   if not quit then Move('Look left  ',138,100,-1,   0,   0, 0,  0,  0, 0);
  1690.   if not quit then Move('Wait       ',  0,  0,30,   0,   0, 0,  0,  0, 0);
  1691.   if not quit then Move('Look right ',100,140, 1,   0,   0, 0,  0,  0, 0);
  1692.   if not quit then Move('accelerate ',140,  0, 1,   1,  71, 2,  0,  0, 0);
  1693.   if not quit then Move('high speed ',  0,  0, 0,  71, 161, 2,  0,  0, 0);
  1694.   if not quit then Move('corner     ',  1, 45, 2,   0,   0, 0,  0,  0, 0);
  1695.   if not quit then Move('straigt    ',  0,  0,45,   0,   0, 0,  0,  0, 0);
  1696.   if not quit then Move('avoid      ', 45, 32,-1,   0,   0, 0, 45, 71, 2);
  1697.   if not quit then Move('           ', 32, 58, 1,   0,   0, 0, 71,111, 2);
  1698.   if not quit then Move('           ', 58, 45,-1, 161, 251, 0,111, 45,-3);
  1699.   if not quit then Move('           ',  0,  0,13,   0,   0, 0,  0,  0, 0);
  1700.   if not quit then Move('Go artifact',  0,  0, 0, 251,   1,-10, 0,  0, 0);
  1701.   if not quit then Move('See it     ',  0,  0,20,   0,   0, 0,  0,  0, 0);
  1702.   if not quit then Move('Turn back  ',110, 95,-1,   1,  41, 2, 45, 10,-1);
  1703.   if not quit then Move('Further    ', 95, 75,-2,  40,   0,-4, 10,  0,-1);
  1704.   if not quit then Move('Turn left  ',179,169,-1,   1,  41, 4,  0,  0, 0);
  1705.   if not quit then Move('Speed      ',169,141,-2,  41, 185, 4,  0,  0, 0);
  1706.   if not quit then Move('Bounce     ',141,131,-1, 185, 221, 4,  0,  0, 0);
  1707.   if not quit then Move('Appr. wall ',  0,  0,10,   0,   0, 0,  0,  0, 0);
  1708.   if not quit then Move('Hit wall   ',131,135, 1,   0,   0, 0,  0,  0, 0);
  1709.   if not quit then Move('Beng       ',  0,  0, 2,   0,   0, 0,  0,  0, 0);
  1710.   r:=45;
  1711.   if not quit then Move('Stop bounce',  0,  0, 0, 216,   0,-8,135,135, 0);
  1712.   if not quit then Move('go forward ',135,135, 0,   2,  42, 4,  0,  0, 0);
  1713.   if not quit then Move('avoid wall ',135,150, 1,  42,  82, 2,  0,  0, 0);
  1714.   if not quit then Move('           ',  0,  0, 6,   0,   0, 0,  0,  0, 0);
  1715.   if not quit then Move('past wall  ',150,135,-1,   0,   0, 0,  0,  0, 0);
  1716.   if not quit then Move('           ',  0,  0,10,   0,   0, 0,  0,  0, 0);
  1717.   if not quit then Move('           ',135,120,-1,   0,   0, 0,  0,  0, 0);
  1718.   if not quit then Move('           ',120,135, 1,   0,   0, 0,  0,  0, 0);
  1719.   if not quit then Move('           ',  0,  0,17,   0,   0, 0,  0,  0, 0);
  1720.   if not quit then Move('turn right ',136,178, 2,   0,   0, 0,  0,  0, 0);
  1721.   if not quit then Move('go in room ',  0,  0, 0,  82, 154, 4,  0,  0, 0);
  1722.   if not quit then Move('allign     ',178,  0, 1, 154, 190, 4,  0,  0, 0);
  1723.   if not quit then Move('           ',  0,  0,10,   0,   0, 0,  0,  0, 0);
  1724.  
  1725.   v:=190;
  1726.   r:=0;
  1727.   x2:=-1402;
  1728.   y2:=-2585;
  1729.   if not quit then Move('Look back  ',  0,  0, 0,   0,   0, 0,179,155,-3);
  1730.   if not quit then Move('and stop   ',  0,  0, 0, 184,   0,-8,153, 90,-3);
  1731.   if not quit then Move('Avoid pilar', 90, 98, 1,   1,   9, 1,  0,  0, 0);
  1732.   if not quit then Move('           ',  0,  0, 0,   9,  41, 4,  0,  0, 0);
  1733.   if not quit then Move('           ', 98, 92,-1,  41,  65, 4,  0,  0, 0);
  1734.   if not quit then Move('           ',  0,  0, 3,   0,   0, 0,  0,  0, 0);
  1735.   if not quit then Move('           ', 90,135, 3,  65,  89, 2,  0,  0, 0);
  1736.   if not quit then Move('           ',  0,  0, 0,  89, 149, 4,  0,  0, 0);
  1737.   if not quit then Move('           ',  0,  0, 7,   0,   0, 0,  0,  0, 0);
  1738.   if not quit then Move('           ',135,157, 2,   0,   0, 0,  0,  0, 0);
  1739.   if not quit then Move('           ',158, 45, 1,   0,   0, 0,  0,  0, 0);
  1740.   if not quit then Move('           ',  0,  0,37,   0,   0, 0,  0,  0, 0);
  1741.   if not quit then Move('           ', 45,137, 4,   0,   0, 0,  0,  0, 0);
  1742.   if not quit then Move('           ',  0,  0, 0, 149, 101,-2,137, 21, 2);
  1743.   if not quit then Move('           ',  0,  0, 0,  96,   0,-6, 21, 45, 2);
  1744.   if not quit then Move('           ', 45, 45, 0,   1,  21, 2,  0,  0, 0);
  1745.   if not quit then Move('           ',  0,  0, 2,   0,   0, 0,  0,  0, 0);
  1746.   if not quit then Move('           ', 45, 90, 1,  21,  45, 1,  0,  0, 0);
  1747.   if not quit then Move('           ',  0,  0, 0,  44,   0,-4,  0,  0, 0);
  1748.  
  1749.   x2:=-1551;
  1750.   y2:=-9232;
  1751.   r:=90;
  1752.   v:=0;
  1753.   DrawInside(x2,y2,r);
  1754.   { Blok laten zakken (shit best wel moeilijk) }
  1755.   if not quit then begin
  1756.      for i:=20 to 67 do by[i]:=round(4096*(((154-104)+((24/47)*(67-i)))/(178-104)));
  1757.      for i:=81 to 224 do by[i]:=round(4096*((154-104)/(178-104)));
  1758.      for i:=250 to 295 do by[i]:=round(4096*(((154-104)+((24/45)*(i-250)))/(178-104)));
  1759.      for i:=31 to 104 do begin
  1760.         for c:=20 to 295 do mem[$a000:i*320+c]:=mem[s2:i*320+c];
  1761.         for c:=67 to 157 do begin
  1762.            a1:=(160-(c-66));
  1763.            if ((a1+i-31)<178) then mem[$a000:c+(a1+i-31)*320]:=1;
  1764.         end;
  1765.         for c:=158 to 247 do begin
  1766.            a1:=c-88;
  1767.            if ((a1+i-31)<178) then mem[$a000:c+(a1+i-31)*320]:=1;
  1768.         end;
  1769.         WaitVbl;
  1770.         WaitVbl;
  1771.      end;
  1772.      for i:=105 to 178 do begin
  1773.         for c:=67 to 157 do begin
  1774.            a1:=(160-(c-66));
  1775.            if ((a1+i-31)<178) then mem[$a000:c+(a1+i-31)*320]:=1;
  1776.         end;
  1777.         for c:=158 to 247 do begin
  1778.            a1:=c-88;
  1779.            if ((a1+i-31)<178) then mem[$a000:c+(a1+i-31)*320]:=1;
  1780.         end;
  1781.  
  1782.         for c:=20 to 67 do begin
  1783.            a1:=(((by[c]*(i-105)) shr 12)+104)*320+c;
  1784.            mem[$a000:a1]:=mem[s2:a1];
  1785.         end;
  1786.         for c:=250 to 295 do begin
  1787.            a1:=(((by[c]*(i-105)) shr 12)+104)*320+c;
  1788.            mem[$a000:a1]:=mem[s2:a1];
  1789.         end;
  1790.         a1:=(((by[81]*(i-105)) shr 12)+104)*320;
  1791.         for c:=68 to 249 do mem[$a000:a1+c]:=mem[s2:a1+c];
  1792.         WaitVbl;
  1793.         WaitVbl;
  1794.      end;
  1795.   end;
  1796.  
  1797.   mem[s1:6077]:=55;  {muur vervangen door zwarte vlakken}
  1798.   mem[s1:6078]:=55;
  1799.   for x:=0 to 255 do meml[s3:14*1024+x shl 2]:=0;
  1800.   for x:=0 to 31 do meml[s3:x*32+13]:=2;
  1801.   x2:=-1551;
  1802.   y2:=-9232;
  1803.   r:=90;
  1804.   v:=0;
  1805.   SetPalette;
  1806.   if not quit then Move('           ',  0,  0,20,   0,   0, 0,  0,  0, 0);
  1807.   if not quit then Move('End movie  ', 90, 50,-1,  -1, -21,-2,  0,  0, 0);
  1808.   if not quit then Move('           ',  0,  0, 0, -20,   0, 2,  0,  0, 0);
  1809.   if not quit then Move('           ', 50, 30,-1,   2, 102, 4,  0,  0, 0);
  1810.   if not quit then Move('           ', 30, 45, 1, 102, 178, 4,  0,  0, 0);
  1811.   if not quit then Move('           ',  0,  0, 0, 176,   0,-8,  0,  0, 0);
  1812.   if not quit then Move('           ', 45, 16,-1,   0,   0, 0,  0,  0, 0);
  1813.   if not quit then Move('           ', 16, 50, 2,   0,   0, 0,  0,  0, 0);
  1814.   if not quit then Move('           ', 50, 90, 2,   2, 142, 4,  0,  0, 0);
  1815.   if not quit then Move('           ', 90, 45,-3,   0,   0, 0,  0,  0, 0);
  1816.   if not quit then Move('           ',  0,  0,10,   0,   0, 0,  0,  0, 0);
  1817.   if not quit then Move('           ', 45, 21,-3,   0,   0, 0,  0,  0, 0);
  1818.   if not quit then Move('           ', 21,  0,-3,   0,   0, 0, 21,157,-4);
  1819.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,157,154,-3);
  1820.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,154,152,-2);
  1821.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,152,151,-1);
  1822.   if not quit then Move('           ',  0,  0, 0, 142, 140,-2,151,151, 0);
  1823.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,151,152, 1);
  1824.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,152,154, 2);
  1825.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,154,  1, 3);
  1826.   if not quit then Move('           ',  1, 28, 3,   0,   0, 0,  0,  0, 0);
  1827.   if not quit then Move('           ',  0,  0,22,   0,   0, 0,  0,  0, 0);
  1828.  
  1829.   x2:=11247;
  1830.   y2:=-13750;
  1831.   r:=28;
  1832.   v:=140;
  1833.   if not quit then Move('           ', 29, 45, 1, 140,  32,-3,  0,  0, 0);
  1834.   if not quit then Move('           ', 45, 90, 3,   0,   0, 0,  0,  0, 0);
  1835.   if not quit then Move('           ',  0,  0, 0,  32, 320, 8,  0,  0, 0);
  1836.   r:=0; {smash}
  1837.   if not quit then Move('           ',  0,  0,15,   0,   0, 0, 88, 10,-6);
  1838.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0, 10,  6,-4);
  1839.   if not quit then Move('           ',  0,  0, 0,   0,   0, 0,  6,  0,-2);
  1840.   if not quit then Move('           ',179,131,-6,   0,   0, 0,  0,  0, 0);
  1841.   if not quit then Move('           ',131,126,-5,   0,   0, 0,  0,  0, 0);
  1842.   if not quit then Move('           ',126,122,-4,   0,   0, 0,  0,  0, 0);
  1843.   if not quit then Move('           ',122,119,-3,   0,   0, 0,  0,  0, 0);
  1844.   if not quit then Move('           ',119, 97,-2,   0,   0, 0,  0,  0, 0);
  1845.   if not quit then Move('           ', 97, 90,-1,   0,   0, 0,  0,  0, 0);
  1846.   if not quit then Move('           ',  0,  0,10,   0,   0, 0,  0,  0, 0);
  1847.   if not quit then Move('           ',  0,  0, 0, 320, 264,-8,  0,  0, 0);
  1848.   if not quit then Move('           ', 90, 54,-3,   0,   0, 0,  0,  0, 0);
  1849.   if not quit then Move('           ', 54, 48,-2,   0,   0, 0,  0,  0, 0);
  1850.   if not quit then Move('           ', 48, 45,-1,   0,   0, 0,  0,  0, 0);
  1851.   if not quit then Move('           ',  0,  0, 1,   0,   0, 0,  0,  0, 0);
  1852.   for a1:=0 to 15999 do meml[$a000:a1 shl 2]:=$2020202;
  1853.   for i:=0 to 63 do begin
  1854.      palette(2,63-i,0,0);
  1855.      WaitVbl;
  1856.   end;
  1857.   EndOfDemo;
  1858. end.
  1859.  
  1860.  
  1861.  
  1862.  
  1863.  
  1864.  
  1865.